package 线程andJUC;

public class main2 {
    /*
    线程常见的成员方法：
    static thread currentThread()     获得当前线程的对象
    static void  sleep(long time)     让线程休眠指定的时间，单位为毫秒值
    public static void  join()         等待该线程终止（插入线程，插队线程）
    public static void  yield()         出让线程/礼让线程
    setPriority(int newPriority)        设置线程的优先级
    final int getPriority()             获取线程的优先级
     */
    public static void main(String[] args) throws InterruptedException {
        /*
//        sleep：使线程停止一段时间，将处于阻塞状态
//        如果调用了sleep方法后，没有其他等待执行的线程，这个时候当前线程不会马上恢复执行
//        创建ThreadSleep类的对象
        ThreadSleep  ts1=new ThreadSleep();
        ThreadSleep  ts2=new ThreadSleep();
        ThreadSleep  ts3=new ThreadSleep();
//        为对象命名
        ts1.setName("zhangsan");
        ts2.setName("lisi");
        ts3.setName("wangwu");
//        启动进程
//        ts1.start();
//        ts2.start();
//        ts3.start();


         */



//        礼让线程  public static void  yield()
          ThreadYield  tv1=new ThreadYield();
          ThreadYield  tv2=new ThreadYield();

          tv1.setName("飞机");
          tv2.setName("坦克");

//          tv1.start();
//          tv2.start();
//          打印是随机的：有可能一遍打印飞机，一遍打印坦克。也有可能先把飞机打印完，再打印坦克





/*
//        join：阻塞指定线程等到另一个线程完成以后再继续执行
        ThreadJoin  tj1=new ThreadJoin();
        ThreadJoin  tj2=new ThreadJoin();
        ThreadJoin  tj3=new ThreadJoin();
        tj1.setName("zhangsan");
        tj2.setName("lisi");
        tj3.setName("wangwu");
        tj1.start();
//        表示把这个tj1线程，插入到当前线程之前
//        当前线程：sout线程
        tj1.join();
        tj2.start();
//        tj2.join();

        tj3.start();
        System.out.println("mainx");
        //如果没有join，该行首先打印，但加入tj1.join之后,该行会在tj1打印完之后再执行
//      即：对于该方式而言(sout)如果出现xx.join，该方式会在xx.join执行完之后再执行
*/



//          ticket
        /*
        同步代码块：public synchronized void method (){可能会产生线程安全问题的代码}
        同步方法锁的是整个方法的代码，执行效率没有同步代码块效率高
        同步方法锁的是谁？：
        非静态方法：this
        静态方法：当前类的class对象
         */

        MyTicket mt1=new MyTicket();
        MyTicket mt2=new MyTicket();
        MyTicket mt3=new MyTicket();

        mt1.setName("窗口一");
        mt2.setName("窗口二");
        mt3.setName("窗口三");

        mt1.start();
        mt2.start();
        mt3.start();




    }
}
class ThreadSleep  extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+":"+i);
            try{
//                即将每个进程相隔1000ms执行
                Thread.sleep(1000);//1s
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
class ThreadJoin extends  Thread{
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
class ThreadYield extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+":"+i);
//            表示礼让/出让当前cpu的执行权
            Thread.yield();
        }
    }
}
class MyTicket extends Thread{
//    要象所有售卖票的站台共享共同数量的票(票数是一定的) 添加static
//    静态关键字，随着类的增加而增加，且仅加载一次

//    private int ticket=0;
  static  int ticket=0;
    @Override
    public void run(){
        while (true){
            if (ticket<100){
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                ticket++;
                System.out.println(getName()+"正在卖第"+ticket+"张票");
            }else {
                break;
            }
        }
    }
}
